﻿#region Copyright Notice
// This file is part of GestionPedago.
// <description>
// Copyright (C) 2012 ENI Ecole Informatique
// 
// GestionPedago is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// <program> is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Data;
using System.Windows.Input;
using GestionPedago.Services;
using GestionPedago.Services.ES;
using GestionPedago.Services.ES.Modele;
using GestionPedago.View;

namespace GestionPedago.ViewModel
{
    /// <summary>
    /// Classe qui représente l'onglet de gestion des titres/activités/compétences
    /// </summary>
    public class GererTitresVM : OngletVM
    {

        private ICommand addActiviteTitreCommand;
        public ICommand AddActiviteTitreCommand
        {
            get
            {
                if (this.addActiviteTitreCommand == null)
                    this.addActiviteTitreCommand = new RelayCommand(param => this.AddActiviteTitre(param));

                return this.addActiviteTitreCommand;
            }
        }

        /// <summary>
        /// Ajout d'une activité à au titre sélectionné
        /// </summary>
        /// <param name="param">Activité</param>
        public void AddActiviteTitre(object param)
        {
            if (param != null)
            {
                ActiviteES a = param as ActiviteES;
                Titre.ListeActivite.Add(a);
                ActivitesUtilisees.Add(a);
                ActivitesRestants.Remove(a);
                FacadeServices.GetInstance().EnregistrerTitre(new EnregistrerTitreIn(Titre));
            }
        }


        private ICommand delActiviteTitreCommand;
        public ICommand DelActiviteTitreCommand
        {
            get
            {
                if (this.delActiviteTitreCommand == null)
                    this.delActiviteTitreCommand = new RelayCommand(param => this.EnleverActiviteTitre(param));

                return this.delActiviteTitreCommand;
            }
        }

        /// <summary>
        /// Suppression de l'activité au titre sélectionné
        /// </summary>
        /// <param name="param">Activité</param>
        public void EnleverActiviteTitre(object param)
        {
            if (param != null)
            {
                ActiviteES a = param as ActiviteES;
                ActivitesRestants.Add(a);
                Titre.ListeActivite.Remove(a);
                ActivitesUtilisees.Remove(a);
                FacadeServices.GetInstance().EnregistrerTitre(new EnregistrerTitreIn(Titre));
            }
        }



        private ICommand addActiviteCompetenceCommand;
        public ICommand AddActiviteCompetenceCommand
        {
            get
            {
                if (this.addActiviteCompetenceCommand == null)
                    this.addActiviteCompetenceCommand = new RelayCommand(param => this.AddActiviteCompetence(param));

                return this.addActiviteCompetenceCommand;
            }
        }

        /// <summary>
        /// Ajout d'une compétence à l'activité sélectionnée
        /// </summary>
        /// <param name="param">Compétence</param>
        public void AddActiviteCompetence(object param)
        {
            if (param != null)
            {
                CompetenceES a = param as CompetenceES;
                Activite.ListeCompetence.Add(a);
                CompetencesUtilisees.Add(a);
                CompetencesRestants.Remove(a);
                FacadeServices.GetInstance().EnregistrerActivite(new EnregistrerActiviteIn(Activite));
            }
        }


        private ICommand delActiviteCompetenceCommand;
        public ICommand DelActiviteCompetenceCommand
        {
            get
            {
                if (this.delActiviteCompetenceCommand == null)
                    this.delActiviteCompetenceCommand = new RelayCommand(param => this.EnleverActiviteCompetence(param));

                return this.delActiviteCompetenceCommand;
            }
        }

        /// <summary>
        /// Suppression de la compétence à l'activité sélectionnée
        /// </summary>
        /// <param name="param"></param>
        public void EnleverActiviteCompetence(object param)
        {
            if (param != null)
            {
                CompetenceES a = param as CompetenceES;
                CompetencesRestants.Add(a);
                Activite.ListeCompetence.Remove(a);
                CompetencesUtilisees.Remove(a);
                FacadeServices.GetInstance().EnregistrerActivite(new EnregistrerActiviteIn(Activite));
            }
        }



        private ICommand addNewActiviteCommand;
        public ICommand AddNewActiviteCommand
        {
            get
            {
                if (this.addNewActiviteCommand == null)
                    this.addNewActiviteCommand = new RelayCommand(param => this.AjouterNewActivite());

                return this.addNewActiviteCommand;
            }
        }

        /// <summary>
        /// Créer une nouvelle activité
        /// </summary>
        private void AjouterNewActivite()
        {

            AddLibelle addwindow = new AddLibelle("");
            bool? result = addwindow.ShowDialog();
            if (result ?? false)
            {

                if (!string.IsNullOrWhiteSpace(addwindow.Libelle))
                {
                    ActiviteES a = new ActiviteES();
                    a.Libelle = addwindow.Libelle;
                    a = FacadeServices.GetInstance().EnregistrerActivite(new EnregistrerActiviteIn(a)).Activite;
                    ActivitesRestants.Add(a);
                }

            }

        }



        private ICommand updateActiviteCommand;
        public ICommand UpdateActiviteCommand
        {
            get
            {
                if (this.updateActiviteCommand == null)
                    this.updateActiviteCommand = new RelayCommand(param => this.UpdateActivite());

                return this.updateActiviteCommand;
            }
        }

        /// <summary>
        /// Enregistrer le nouveau libellé de l'activité
        /// </summary>
        private void UpdateActivite()
        {

            if (EditActivite != null)
            {

                AddLibelle addwindow = new AddLibelle(EditActivite.Libelle);
                bool? result = addwindow.ShowDialog();
                if (result ?? false)
                {

                    if (!string.IsNullOrWhiteSpace(addwindow.Libelle))
                    {
                        EditActivite.Libelle = addwindow.Libelle;
                        EditActivite = FacadeServices.GetInstance().EnregistrerActivite(new EnregistrerActiviteIn(EditActivite)).Activite;
                        ICollectionView view = CollectionViewSource.GetDefaultView(ActivitesRestants);
                        view.Refresh();
                    }

                }

            }

            
        }




        private ICommand delActiviteCommand;
        public ICommand DelActiviteCommand
        {
            get
            {
                if (this.delActiviteCommand == null)
                    this.delActiviteCommand = new RelayCommand(param => this.SupprimerActivite());

                return this.delActiviteCommand;
            }
        }

        /// <summary>
        /// Supprimé définitivement une activité.
        /// </summary>
        private void SupprimerActivite()
        {
            if (EditActivite != null)
            {
                ActivitesRestants.Remove(EditActivite);
                FacadeServices.GetInstance().SupprimerActivite(new SupprimerActiviteIn(EditActivite));
                if(ActivitesRestants.Count > 0)
                    EditActivite = ActivitesRestants[0];
            }
        }



        private ICommand addNewCompetenceCommand;
        public ICommand AddNewCompetenceCommand
        {
            get
            {
                if (this.addNewCompetenceCommand == null)
                    this.addNewCompetenceCommand = new RelayCommand(param => this.AjouterNewCompetence());

                return this.addNewCompetenceCommand;
            }
        }

        /// <summary>
        /// Créer une nouvelle compétence
        /// </summary>
        private void AjouterNewCompetence()
        {

            AddLibelle addwindow = new AddLibelle("");
            bool? result = addwindow.ShowDialog();
            if (result ?? false)
            {

                if (!string.IsNullOrWhiteSpace(addwindow.Libelle))
                {
                    CompetenceES a = new CompetenceES();
                    a.Libelle = addwindow.Libelle;
                    a = FacadeServices.GetInstance().EnregistrerCompetence(new EnregistrerCompetenceIn(a)).Competence;
                    CompetencesRestants.Add(a);
                }

            }

        }



        private ICommand updateCompetenceCommand;
        public ICommand UpdateCompetenceCommand
        {
            get
            {
                if (this.updateCompetenceCommand == null)
                    this.updateCompetenceCommand = new RelayCommand(param => this.UpdateCompetence());

                return this.updateCompetenceCommand;
            }
        }

        /// <summary>
        /// Enregistre le nouveau libellé d'une compétence
        /// </summary>
        private void UpdateCompetence()
        {

            if (EditCompetence != null)
            {

                AddLibelle addwindow = new AddLibelle(EditCompetence.Libelle);
                bool? result = addwindow.ShowDialog();
                if (result ?? false)
                {

                    if (!string.IsNullOrWhiteSpace(addwindow.Libelle))
                    {
                        EditCompetence.Libelle = addwindow.Libelle;
                        EditCompetence = FacadeServices.GetInstance().EnregistrerCompetence(new EnregistrerCompetenceIn(EditCompetence)).Competence;
                        ICollectionView view = CollectionViewSource.GetDefaultView(CompetencesRestants);
                        view.Refresh();
                    }

                }

            }

        }



        private ICommand delCompetenceCommand;
        public ICommand DelCompetenceCommand
        {
            get
            {
                if (this.delCompetenceCommand == null)
                    this.delCompetenceCommand = new RelayCommand(param => this.SupprimerCompetence());

                return this.delCompetenceCommand;
            }
        }


        /// <summary>
        /// Supprimer définitivement une compétence
        /// </summary>
        private void SupprimerCompetence()
        {
            if (EditCompetence != null)
            {
                CompetencesRestants.Remove(EditCompetence);
                FacadeServices.GetInstance().SupprimerCompetence(new SupprimerCompetenceIn(EditCompetence));
                if(CompetencesRestants.Count > 0)
                    EditCompetence = CompetencesRestants[0];
            }
        }



        private ObservableCollection<TitreES> pTitres;
        /// <summary>
        /// Liste des titres de la liste déroulante
        /// </summary>
        public ObservableCollection<TitreES> Titres
        {
            get { return pTitres; }
            set
            {
                if (value != null)
                {
                    pTitres = value;
                    RaisePropertyChanged("Titres");
                }

            }
        }

        private TitreES pTitre;
        /// <summary>
        /// Titre sélectionné dans la liste déroulante
        /// </summary>
        public TitreES Titre
        {
            get { return pTitre; }
            set
            {
                if (value != null)
                {
                    pTitre = value;
                    RaisePropertyChanged("Titre");
                    ActivitesRestants = new ObservableCollection<ActiviteES>(Activites);
                    ActivitesUtilisees = new ObservableCollection<ActiviteES>(pTitre.ListeActivite);
                    foreach (ActiviteES a in pTitre.ListeActivite)
                        ActivitesRestants.Remove(a);
                    SwitchActivites = true;
                }
                else
                {
                    SwitchActivites = false;
                }

            }
        }


        

        private ObservableCollection<ActiviteES> pActivites;
        /// <summary>
        /// Liste de toutes les activités
        /// </summary>
        public ObservableCollection<ActiviteES> Activites
        {
            get { return pActivites; }
            set
            {
                if (value != null)
                {
                    pActivites = value;
                    RaisePropertyChanged("Activites");
                }

            }
        }

        private ObservableCollection<ActiviteES> pActivitesUtilisees;
        /// <summary>
        /// Liste des activités du titre sélectionné
        /// </summary>
        public ObservableCollection<ActiviteES> ActivitesUtilisees
        {
            get { return pActivitesUtilisees; }
            set
            {
                if (value != null)
                {
                    pActivitesUtilisees = value;
                    RaisePropertyChanged("ActivitesUtilisees");
                }

            }
        }

        private ObservableCollection<ActiviteES> pActivitesRestants;
        /// <summary>
        /// Liste des activités non utilisées par le titre sélectionné
        /// </summary>
        public ObservableCollection<ActiviteES> ActivitesRestants
        {
            get { return pActivitesRestants; }
            set
            {
                if (value != null)
                {
                    pActivitesRestants = value;
                    RaisePropertyChanged("ActivitesRestants");
                }

            }
        }

        private ActiviteES pActivite;
        /// <summary>
        /// Activité sélectionné dans la liste déroulante
        /// </summary>
        public ActiviteES Activite
        {
            get { return pActivite; }
            set
            {
                if (value != null)
                {
                    pActivite = value;
                    RaisePropertyChanged("Activite");
                    CompetencesRestants = new ObservableCollection<CompetenceES>(Competences);
                    CompetencesUtilisees = new ObservableCollection<CompetenceES>(pActivite.ListeCompetence);
                    foreach (CompetenceES c in pActivite.ListeCompetence)
                        CompetencesRestants.Remove(c);
                    SwitchCompetences = true;
                }
                else
                {
                    SwitchCompetences = false;
                }

            }
        }

        private ActiviteES pEditActivite;
        /// <summary>
        /// Activité sélectionné dans la liste des activités non utilisées par le titre sélectionné
        /// </summary>
        public ActiviteES EditActivite
        {
            get { return pEditActivite; }
            set
            {
                if (value != null)
                {
                    pEditActivite = value;
                    RaisePropertyChanged("EditActivite");
                }

            }
        }

        private string newActivite;
        /// <summary>
        /// Libellé de la nouvelle activité à ajouter
        /// </summary>
        public string NewActivite
        {
            get { return newActivite; }
            set
            {
                newActivite = value;
                RaisePropertyChanged("NewActivite");
            }
        }



        private ObservableCollection<CompetenceES> pCompetences;
        /// <summary>
        /// Liste de toutes les compétences
        /// </summary>
        public ObservableCollection<CompetenceES> Competences
        {
            get { return pCompetences; }
            set
            {
                if (value != null)
                {
                    pCompetences = value;
                    RaisePropertyChanged("Competences");
                }

            }
        }

        private ObservableCollection<CompetenceES> pCompetencesUtilisees;
        /// <summary>
        /// Liste des compétences de l'activité sélectionnée
        /// </summary>
        public ObservableCollection<CompetenceES> CompetencesUtilisees
        {
            get { return pCompetencesUtilisees; }
            set
            {
                if (value != null)
                {
                    pCompetencesUtilisees = value;
                    RaisePropertyChanged("CompetencesUtilisees");
                }

            }
        }

        private ObservableCollection<CompetenceES> pCompetencesRestants;
        /// <summary>
        /// Liste des compétences non utilisées par l'activité sélectionnée
        /// </summary>
        public ObservableCollection<CompetenceES> CompetencesRestants
        {
            get { return pCompetencesRestants; }
            set
            {
                if (value != null)
                {
                    pCompetencesRestants = value;
                    RaisePropertyChanged("CompetencesRestants");
                }

            }
        }

        private CompetenceES pEditCompetence;
        /// <summary>
        /// Compétence sélectionnée dans la liste des compétences non utilisées par l'activité sélectionnée
        /// </summary>
        public CompetenceES EditCompetence
        {
            get { return pEditCompetence; }
            set
            {
                if (value != null)
                {
                    pEditCompetence = value;
                    RaisePropertyChanged("EditCompetence");
                }

            }
        }

        /// <summary>
        /// Libellé de la nouvelle compétence à ajouter
        /// </summary>
        public string NewCompetence { get; set; }


        private bool switchActivites;
        /// <summary>
        /// Activiation des boutons Ajouter/Enlever pour les activités
        /// </summary>
        public bool SwitchActivites
        {
            get { return switchActivites; }
            set
            {
                switchActivites = value;
                RaisePropertyChanged("SwitchActivites");
            }
        }

        private bool switchCompetences;
        /// <summary>
        /// Activiation des boutons Ajouter/Enlever pour les compétences
        /// </summary>
        public bool SwitchCompetences
        {
            get { return switchCompetences; }
            set
            {
                switchCompetences = value;
                RaisePropertyChanged("SwitchCompetences");
            }
        }


        /// <summary>
        /// Constructeur pour la classe GererTitresVM
        /// </summary>
        /// <param name="parent">Gestionnaire d'onglet</param>
        public GererTitresVM(GestionnaireOngletsVM parent)
        {
            base.DisplayName = "Gérer les titres";
            base.Parent = parent;
            Titres = new ObservableCollection<TitreES>(FacadeServices.GetInstance().RecupererTitres(new RecupererTitresIn()).ListeTitres);
            Activites = new ObservableCollection<ActiviteES>(FacadeServices.GetInstance().RecupererActivites(new RecupererActivitesIn()).ListeActivites);
            Competences = new ObservableCollection<CompetenceES>(FacadeServices.GetInstance().RecupererCompetences(new RecupererCompetencesIn()).ListeCompetences);

            ActivitesRestants = new ObservableCollection<ActiviteES>(Activites);
            CompetencesRestants = new ObservableCollection<CompetenceES>(Competences);

            SwitchActivites = false;
            SwitchCompetences = false;
        }


    }
}
